//package xixi;
//
//import java.awt.BorderLayout;
//import java.awt.Color;
//import java.awt.Font;
//import java.awt.GridLayout;
//import java.awt.Insets;
//import java.awt.event.ActionEvent;
//import java.awt.event.ActionListener;
//import javax.swing.*;
//import javax.swing.event.CaretEvent;
//import javax.swing.event.CaretListener;
//import java.util.ArrayList;
//import java.awt.FlowLayout;
//import java.sql.*;
//import java.util.Date;
//import java.text.SimpleDateFormat;
//import java.text.*;
//import java.text.ParseException;
//
///**
// * 计算器类，继承自JFrame，实现了ActionListener和CaretListener接口
// * 
// * JFrame：
// * JFrame 是 Swing 包中的一个类，用于创建一个窗口界面。它是所有顶层窗口的基本类型，提供了图形用户界面的框架。
// * JFrame 可以包含各种图形组件，如按钮、标签、文本框等，通过设置布局管理器，用户可以控制这些组件的显示方式。
// * 主要的功能包括设置窗口标题、设置窗口大小、设置关闭操作、添加组件和显示窗口等。
// * 
// * ActionListener：
// * ActionListener 是一个接口，用于处理按钮点击等动作事件。当用户在 GUI 中执行某个动作（如点击按钮）时，将触发相应的事件。
// * 开发者需要实现 actionPerformed(ActionEvent e) 方法，以定义在事件发生时应该执行的操作。
// * 通过为组件（如按钮）添加这个监听器，可以响应用户的交互。
// * 
// * CaretListener：
// * CaretListener 也是一个接口，用于监听文本组件（如 JTextField 或 JTextArea）中光标的移动事件。
// * 当文本框中的光标位置变化时，将触发 caretUpdate(CaretEvent e)
// * 方法，开发者可以在这个方法中处理光标移动后的逻辑，例如更新某些组件的状态或者显示相关信息。
// * 这个监听器通常用来监控用户在文本框中进行输入或删除操作后的光标位置变化
// */
//public class Testyyl extends JFrame implements ActionListener, CaretListener { // 定义Test类，继承自JFrame并实现ActionListener和CaretListener接口
//    private JTextField textResult, textReview; // 定义两个文本框，一个用于显示结果，另一个用于显示输入的数学表达式
//    private JButton btns[] = new JButton[30]; // 定义一个按钮数组，预留30个按钮
//    // private String str1, str2; // str1用于存储历史输入的数学表达式，str2用于存储当前输入的数学表达式
//    private String str; // 用于存储当前输入的值
//    private String memory; // 用于存储数值的内存
//    private JPanel menuPanel; // 自定义的菜单栏面板
//    private JButton menuButton; // “≡”按钮，用于显示或隐藏菜单
//    private boolean isMenuVisible = false; // 标记菜单栏是否可见
//    // 声明一个用于显示历史记录的窗口
//    private JDialog historyDialog; // 历史记录对话框
//
//    /**
//     * 构造方法，初始化计算器界面和组件
//     * 
//     * @param str 窗口标题
//     */
//    public Testyyl(String str) { // 构造方法接收窗口标题参数
//        super(str); // 调用父类构造方法设置窗口标题
//        this.setBounds(600, 150, 420, 520); // 设置窗口的大小和位置
//        this.setDefaultCloseOperation(EXIT_ON_CLOSE); // 设置关闭窗口时退出程序
//        // this.setResizable(false); // 不允许调整窗口大小
//        this.getContentPane().setBackground(Color.lightGray); // 设置内容面板的背景颜色为浅灰色
//        this.getContentPane().setLayout(new BorderLayout()); // 设置内容面板的布局为边界布局
//
//        JPanel p1 = new JPanel(); // 创建一个新的JPanel
//        p1.setLayout(new BorderLayout(0, 0)); // 设置面板的布局为边界布局
//
//        // 初始化文本框
//        textResult = createTextField("0", 20); // 创建一个用于显示结果的文本框
//        textReview = createTextField(textResult.getText(), 12); // 创建一个用于显示输入的文本框
//        textReview.setEditable(false); // 设置审查文本框为只读
//
//        // 初始化菜单按钮
//        menuButton = new JButton("≡"); // 创建菜单按钮
//        menuButton.addActionListener(new ActionListener() { // 为菜单按钮添加动作监听器
//            @Override
//            public void actionPerformed(ActionEvent e) { // 点击事件处理
//                toggleMenuVisibility(); // 切换菜单的可见性
//            }
//        });
//
//        JPanel northPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); // 创建一个新的面板，布局为左对齐的流布局
//        northPanel.add(createPanel(textReview, textResult)); // 添加文本框面板到北部区域
//        northPanel.add(menuButton); // 添加菜单按钮到北部区域
//        p1.add(northPanel, BorderLayout.NORTH); // 将新面板添加到p1的北部区域
//
//        // 设置面板及文本框布局
//        setupPanels(p1); // 自定义设置面板布局
//
//        this.getContentPane().add(p1, BorderLayout.NORTH); // 将主面板添加到内容面板的北部
//
//        JPanel p2 = new JPanel(); // 创建一个面板用于放置按钮
//        p2.setLayout(new GridLayout(6, 5, 10, 10)); // 设置为6行5列的网格布局
//        btns = get(btns); // 初始化按钮数组
//        setupButtons(p2); // 设置按钮
//        this.getContentPane().add(p2, BorderLayout.CENTER); // 将按钮面板添加到内容面板的中心
//
//        // 添加文本监听器
//        textResult.addCaretListener(this); // 为结果文本框添加光标监听器
//        textReview.addCaretListener(this); // 为审查文本框添加光标监听器
//
//        // 创建自定义的垂直菜单栏
//        menuPanel = new JPanel(); // 创建菜单面板
//        menuPanel.setLayout(new BoxLayout(menuPanel, BoxLayout.Y_AXIS)); // 设置菜单面板的布局为垂直方向的BoxLayout
//        menuPanel.setBackground(Color.LIGHT_GRAY); // 设置菜单面板的背景颜色为浅灰色
//        menuPanel.setVisible(false); // 初始时菜单面板不可见
//
//        // 添加菜单项
//        String[] menuItems = { "日期计算", "进制转换" };
//        for (String item : menuItems) { // 遍历所有菜单项
//            JButton menuItemButton = new JButton(item); // 创建一个新的按钮，按钮文本为当前菜单项
//            menuItemButton.addActionListener(new ActionListener() { // 为按钮添加动作监听器
//                @Override
//                public void actionPerformed(ActionEvent e) { // 正确处理按钮点击事件
//                    switch (item) {
//                        case "日期计算":
//                            performDateCalculation(); // 调用日期计算逻辑
//                            break;
//                        case "进制转换":
//                            performBaseConversion(); // 调用进制转换逻辑
//                            break;
//                    }
//                }
//            });
//
//            menuPanel.add(menuItemButton); // 将菜单按钮添加到菜单面板中
//        }
//
//        // 将菜单栏添加到窗口中，但初始时不可见
//        this.add(menuPanel, BorderLayout.WEST); // 将菜单面板添加到窗口的西部（左侧）
//
//        this.setVisible(true); // 设置窗口可见
//    }
//
//    /**
//     * 切换菜单可见性的方法
//     */
//    private void toggleMenuVisibility() { // 定义一个方法，用于切换菜单的可见性
//        isMenuVisible = !isMenuVisible; // 反转菜单的可见状态
//        menuPanel.setVisible(isMenuVisible); // 根据当前状态设置菜单面板的可见性
//
//        // 调整窗口大小以适应菜单栏（可选）
//        if (isMenuVisible) { // 如果菜单当前是可见的
//            this.setSize(this.getWidth(), this.getHeight() + menuPanel.getPreferredSize().height); // 增加窗口高度，以适应菜单的高度
//        } else { // 如果菜单当前是不可见的
//            this.setSize(this.getWidth(), this.getHeight() - menuPanel.getPreferredSize().height); // 减少窗口高度，以适应菜单的高度
//        }
//    }
//
//    private void performDateCalculation() {
//        // 输入第一个日期
//        String startDateString = JOptionPane.showInputDialog(this, "请输入起始日期（格式：yyyy-MM-dd）：");
//        if (startDateString == null) {
//            return; // 如果取消输入，直接返回
//        }
//
//        // 输入第二个日期
//        String endDateString = JOptionPane.showInputDialog(this, "请输入结束日期（格式：yyyy-MM-dd）：");
//        if (endDateString == null) {
//            return; // 如果取消输入，直接返回
//        }
//
//        // 解析日期
//        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
//        try {
//            Date startDate = dateFormat.parse(startDateString); // 解析起始日期
//            Date endDate = dateFormat.parse(endDateString); // 解析结束日期
//
//            // 计算两个日期之间的相差天数
//            long differenceInMillis = endDate.getTime() - startDate.getTime(); // 毫秒差
//            long daysDifference = differenceInMillis / (1000 * 60 * 60 * 24); // 计算天数
//
//            // 显示结果
//            JOptionPane.showMessageDialog(this, "两个日期之间相差 " + daysDifference + " 天");
//        } catch (ParseException e) {
//            JOptionPane.showMessageDialog(this, "日期格式不正确，请使用 `yyyy-MM-dd` 格式。", "错误", JOptionPane.ERROR_MESSAGE);
//        }
//    }
//
//    private void performBaseConversion() {
//        String input = JOptionPane.showInputDialog(this, "请输入一个十进制数：");
//        if (input != null) {
//            try {
//                int decimal = Integer.parseInt(input);
//                String binary = Integer.toBinaryString(decimal); // 转换为二进制
//                String octal = Integer.toOctalString(decimal); // 转换为八进制
//                String hexadecimal = Integer.toHexString(decimal).toUpperCase(); // 转换为十六进制
//
//                // 显示转换结果
//                JOptionPane.showMessageDialog(this,
//                        "二进制: " + binary + "\n" +
//                                "八进制: " + octal + "\n" +
//                                "十六进制: " + hexadecimal);
//            } catch (NumberFormatException e) {
//                JOptionPane.showMessageDialog(this, "无效输入，请输入一个有效的十进制数。", "错误", JOptionPane.ERROR_MESSAGE);
//            }
//        }
//    }
//
//    /**
//     * 显示历史记录对话框的方法
//     */
//    private void showHistoryDialog() { // 定义一个方法，用于显示历史记录对话框
//        if (historyDialog == null) { // 检查历史记录对话框是否已经创建
//            // 如果历史记录对话框尚未创建，则创建它
//            historyDialog = new JDialog(this, "历史记录", true); // 创建一个模态对话框，标题为“历史记录”
//            historyDialog.setSize(400, 300); // 设置对话框的大小为400x300像素
//            historyDialog.setLayout(new BorderLayout()); // 设置对话框的布局为边界布局
//
//            // 创建历史记录文本区域和滚动面板
//            JTextArea historyTextArea = createHistoryTextArea(); // 调用方法创建历史记录文本区域
//            JScrollPane scrollPane = new JScrollPane(historyTextArea); // 创建一个滚动面板，将文本区域放入其中
//            historyDialog.add(scrollPane, BorderLayout.CENTER); // 将滚动面板添加到对话框的中心区域
//
//            // 创建关闭按钮面板
//            JPanel buttonPanel = new JPanel(); // 创建一个新的面板用于放置按钮
//            JButton closeButton = new JButton("关闭"); // 创建一个关闭按钮，文本为“关闭”
//            closeButton.addActionListener(new ActionListener() { // 为关闭按钮添加动作监听器
//                @Override
//                public void actionPerformed(ActionEvent e) { // 当按钮被点击时
//                    historyDialog.dispose(); // 关闭对话框
//                }
//            });
//            buttonPanel.add(closeButton); // 将关闭按钮添加到按钮面板中
//            historyDialog.add(buttonPanel, BorderLayout.SOUTH); // 将按钮面板添加到对话框的南部区域
//
//            // 填充历史记录数据（这里简化处理，你可以从数据库读取）
//            ArrayList<String> historyList = readHistoryFromDatabase(); // 从数据库读取历史记录
//            for (String history : historyList) { // 遍历历史记录列表
//                historyTextArea.append(history + "\n"); // 将每条历史记录添加到文本区域中，并换行
//            }
//        }
//        historyDialog.setVisible(true); // 显示对话框
//    }
//
//    /**
//     * 创建历史记录文本区域的方法
//     */
//    private JTextArea createHistoryTextArea() { // 定义一个方法以创建历史记录文本区域
//        JTextArea textArea = new JTextArea(); // 创建一个新的文本区域
//        textArea.setEditable(false); // 设置文本区域为只读
//        textArea.setLineWrap(true); // 启用自动换行
//        textArea.setWrapStyleWord(true); // 设置在单词边界换行
//        return textArea; // 返回创建的文本区域
//    }
//
//    /**
//     * 保存历史记录到数据库的方法
//     */
//    private void saveHistory(String timestamp, String calculationProcess, String finalResult) { // 定义一个方法，用于保存历史记录到数据库
//        String query = "INSERT INTO History (时间, 计算过程, 计算结果) VALUES (?, ?, ?)"; // 构建插入数据库的SQL语句
//        try (Connection conn = DriverManager.getConnection("jdbc:Access:///D:/Access-files/Calculator-history.accdb"); // 连接到Access数据库
//                PreparedStatement stmt = conn.prepareStatement(query)) { // 准备SQL语句
//            stmt.setString(1, timestamp); // 设置第一个参数为时间戳
//            stmt.setString(2, calculationProcess); // 设置第二个参数为计算过程
//            stmt.setString(3, finalResult); // 设置第三个参数为计算结果
//            stmt.executeUpdate(); // 执行插入操作
//        } catch (SQLException e) { // 捕获SQL异常
//            e.printStackTrace(); // 打印异常堆栈跟踪
//        }
//    }
//
//    /**
//     * 从数据库读取历史记录的方法
//     */
//    private ArrayList<String> readHistoryFromDatabase() { // 定义一个方法，用于从数据库读取历史记录
//        ArrayList<String> historyList = new ArrayList<>(); // 创建一个ArrayList用于存储历史记录
//
//        // 使用正确的列名，并且不要将列名放在引号中（除非它们是保留字或包含特殊字符）
//        String query = "SELECT * FROM History"; // 构建查询数据库的SQL语句
//
//        try (Connection conn = DriverManager.getConnection("jdbc:Access:///D:/Access-files/Calculator-history.accdb"); // 连接到Access数据库
//                Statement stmt = conn.createStatement(); // 创建Statement对象用于执行查询
//                ResultSet rs = stmt.executeQuery(query)) { // 执行查询并获取结果集
//
//            while (rs.next()) { // 遍历结果集中的每一行
//                String timestamp = rs.getString("时间"); // 读取时间戳
//                String calculationProcess = rs.getString("计算过程"); // 读取计算过程
//                String historyResult = rs.getString("计算结果"); // 读取计算结果
//                // 根据需要格式化显示内容
//                historyList.add(timestamp + "计算结果: " + calculationProcess + historyResult); // 将 formatted history
//                // record 添加到历史记录列表中
//            }
//        } catch (SQLException e) { // 捕获SQL异常
//            e.printStackTrace(); // 打印异常堆栈跟踪
//        }
//        return historyList; // 返回读取到的历史记录列表
//    }
//
//    /**
//     * 创建文本框的方法
//     */
//    private JTextField createTextField(String text, int fontSize) {
//        JTextField textField = new JTextField(text, 5);
//        textField.setHorizontalAlignment(JTextField.RIGHT); // 设置文本框内容右对齐
//        textField.setFont(new Font("Arial", Font.BOLD, fontSize)); // 设置文本框字体
//        return textField;
//    }
//
//    /**
//     * 设置面板及文本框布局
//     */
//    private void setupPanels(JPanel p1) {
//        p1.add(createPanel(textReview, textResult), BorderLayout.CENTER);
//        p1.add(new JPanel(), BorderLayout.WEST); // 西部面板
//        p1.add(new JPanel(), BorderLayout.EAST); // 东部面板
//        p1.add(new JPanel(), BorderLayout.SOUTH); // 南部面板
//    }
//
//    /**
//     * 创建包含两个文本框的显示面板
//     */
//    private JPanel createPanel(JTextField topField, JTextField bottomField) {
//        JPanel panel = new JPanel();
//        panel.setLayout(new GridLayout(2, 1, 0, -2)); // 设置为2行1列的网格布局
//        panel.add(topField); // 添加审查文本框
//        panel.add(bottomField); // 添加结果文本框
//        return panel;
//    }
//
//    /**
//     * 设置按钮的方法
//     */
//    private void setupButtons(JPanel p2) {
//        for (JButton btn : btns) { // 遍历按钮数组
//            p2.add(btn); // 将每个按钮添加到面板中
//            btn.setMargin(new Insets(0, 0, 0, 0)); // 设置按钮的边缘空余部分为0
//            btn.setFont(new Font("Arial", Font.ROMAN_BASELINE, btn == btns[btns.length - 1] ? 12 : 15)); // 设置字体
//            btn.addActionListener(this); // 为每个按钮添加事件监听器
//        }
//    }
//
//    /**
//     * 获取按钮数组并初始化按钮
//     * 
//     * @param btns2 按钮数组
//     * @return 初始化后的按钮数组
//     */
//    private JButton[] get(JButton[] btns2) { // 定义一个方法，用于初始化按钮数组并返回它
//        String[] buttonLabels = {
//                "MC", "MR", "MS", "M+", "M-",
//                "←", "CE", "C", "±", "√",
//                "7", "8", "9", "/", "%",
//                "4", "5", "6", "*", "1/x",
//                "1", "2", "3", "-", "x^2",
//                "0", ".", "=", "+", "OpenHistory"
//        };
//
//        for (int i = 0; i < btns.length; i++) {
//            try {
//                btns[i] = new JButton(buttonLabels[i]); // 初始化按钮
//            } catch (ArrayIndexOutOfBoundsException e) {
//                System.err.println("按钮初始化异常：" + e.getMessage()); // 错误处理
//            }
//        }
//
//        return btns; // 返回初始化后的按钮数组
//    }
//
//    /**
//     * 处理按钮的点击事件
//     */
//    public void actionPerformed(ActionEvent e) { // 实现ActionListener接口中的方法，处理按钮点击事件
//        /*
//         * MC（Memory Clear）：清除存储器中的数值。
//         * MR（Memory Recall）：读取存储器中存储的数值。
//         * MS（Memory Save）：将当前显示的数值存入存储器中。
//         * M+（Memory Add）：将当前显示的数值与存储器中的数值相加，并将结果存入存储器。
//         * M-（Memory Minus，部分计算器无此功能）：用存储器中的数值减去当前显示的数值，并将结果存入存储器（此功能并非所有计算器都具备）。
//         */
//
//        if (e.getSource() == btns[0]) { // 如果点击的是第0个按钮（MC）
//            memory = "0"; // 将存储器中的数值清零
//        } else if (e.getSource() == btns[1]) { // 如果点击的是第1个按钮（MR）
//            str = memory; // 将结果文本框的内容设置为存储器中的数值
//            textResult.setText(str);
//        } else if (e.getSource() == btns[2]) { // 如果点击的是第2个按钮（MS）
//            memory = textResult.getText(); // 将存储器中的数值设置为结果文本框的内容
//        } else if (e.getSource() == btns[3]) { // 如果点击的是第3个按钮（M+）
//            str = memory + "+" + textResult.getText();
//            String[] s = str.split("\\+"); // 按加号分割字符串成数组
//            System.out.println(s[0] + "   " + s[1]); // 打印两个操作数（用于调试）
//            try {
//                int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
//                memory = String.valueOf(sum); // 更新存储器中的数值
//            } catch (NumberFormatException e1) { // 捕获整数解析异常
//                try {
//                    double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
//                    memory = String.valueOf(sum); // 更新存储器中的数值
//                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                    e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
//                }
//            }
//        } else if (e.getSource() == btns[4]) { // 如果点击的是第4个按钮（M-）
//            str = memory + "-" + textResult.getText();
//            String[] s = str.split("\\-"); // 按减号分割字符串成数组
//            if (str.charAt(0) == '-') { // 如果字符串以负号开头
//                s[s.length - 2] = "-" + s[s.length - 2]; // 将减去的数的符号变为负
//                /*
//                 * str.charAt(0) == '-'：检查字符串的第一个字符是否为负号。
//                 * 如果是，则认为表达式是一个负数，接下来的操作数（即减去的数）也应为负数。
//                 * 
//                 * s[s.length - 2] = "-" + s[s.length - 2];：
//                 * 找到数组 s 中倒数第二个元素（即被减数），将其前面加上一个负号，从而将它的符号变为负。
//                 * 这是为了确保在后续的减法操作中，计算时能正确处理负数。
//                 */
//            }
//            try {
//                int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试将操作数解析为整数并相减
//                memory = String.valueOf(sum); // 更新存储器中的数值
//            } catch (NumberFormatException e1) { // 捕获整数解析异常
//                try {
//                    double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相减
//                    memory = String.valueOf(sum); // 更新存储器中的数值
//                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                    // 处理异常
//                }
//            }
//        } else if (e.getSource() == btns[5]) { // 如果点击的是第5个按钮（←，退格）
//            str = textResult.getText(); // 获取结果文本框的内容
//            if (str.length() == 1) { // 如果字符串长度为1
//                textResult.setText("0"); // 设置结果文本框为0
//            } else { // 如果字符串长度大于1
//                str = str.substring(0, str.length() - 1);
//                textResult.setText(str); // 更新结果文本框为新字符串
//            }
//        } else if (e.getSource() == btns[6]) { // 如果点击的是第6个按钮（CE，清除当前输入）
//            textResult.setText("0"); // 清空审查文本框
//        } else if (e.getSource() == btns[7]) { // 如果点击的是第7个按钮（C，清除所有）
//            textResult.setText("0"); // 将结果文本框清空并设置为0
//            textReview.setText(""); // 清空审查文本框
//        } else if (e.getSource() == btns[8]) { // 如果点击的是第8个按钮（±，正负号切换）
//            math(); // 先执行数学运算（以确保状态更新）
//            str = textReview.getText(); // 获取审查文本框的内容
//            str = str.startsWith("-") ? str.substring(1, str.length()) : "-" + str; // 取反
//            textReview.setText(str); // 更新审查文本框为新字符串
//        } else if (e.getSource() == btns[9]) { // 如果点击的是第9个按钮（√，开方）
//            math(); // 执行数学运算，确保状态更新
//            str = textResult.getText(); // 获取结果文本框的内容
//            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                double s = 0; // 初始化一个double变量用于存储结果
//                try {
//                    s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                    s = Math.sqrt(s); // 计算s的平方根
//                } catch (NumberFormatException e2) { // 捕获数字格式异常
//                    // 此处可以添加错误处理逻辑
//                }
//                textReview.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
//                textResult.setText("0"); // 清空结果文本框并重置为0
//            } else { // 如果结果文本框为空
//                str = textReview.getText(); // 获取审查文本框的内容
//                double s = 0; // 初始化一个double变量用于存储结果
//                try {
//                    s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                    s = Math.sqrt(s); // 计算s的平方根
//                } catch (NumberFormatException e2) { // 捕获数字格式异常
//                    // 此处可以添加错误处理逻辑
//                }
//                textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
//            }
//        } else if (e.getSource() == btns[10]) { // 如果点击的是第10个按钮（数字7）
//            number(btns[10].getText()); // 调用数字输入处理方法，传入按钮的文本
//        } else if (e.getSource() == btns[11]) { // 如果点击的是第11个按钮（数字8）
//            number(btns[11].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[12]) { // 如果点击的是第12个按钮（数字9）
//            number(btns[12].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[13]) { // 如果点击的是第13个按钮（/，除法）
//            math();
//            str = textResult.getText();
//            String s = textReview.getText();
//            textReview.setText(s + str + btns[13].getText());
//            textResult.setText("0");
//        } else if (e.getSource() == btns[14]) { // 如果点击的是第14个按钮（%）
//            math(); // 执行数学运算，确保状态更新
//            str = textResult.getText(); // 获取结果文本框的内容
//            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                double s = 0; // 初始化一个double变量用于存储结果
//                try {
//                    s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
//                } catch (NumberFormatException e1) { // 捕获数字格式异常
//                    try {
//                        s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
//                    } catch (NumberFormatException e2) { // 捕获数字格式异常
//                        // 此处可以添加错误处理逻辑
//                    }
//                }
//                textResult.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
//            } else { // 如果结果文本框为空
//                str = textReview.getText(); // 获取审查文本框的内容
//                double s = 0; // 初始化一个double变量用于存储结果
//                try {
//                    s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
//                } catch (NumberFormatException e1) { // 捕获数字格式异常
//                    try {
//                        s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
//                    } catch (NumberFormatException e2) { // 捕获数字格式异常
//                        // 此处可以添加错误处理逻辑
//                    }
//                }
//                textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
//            }
//        } else if (e.getSource() == btns[15]) { // 如果点击的是第15个按钮（数字4）
//            number(btns[15].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[16]) { // 如果点击的是第16个按钮（数字5）
//            number(btns[16].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[17]) { // 如果点击的是第17个按钮（数字6）
//            number(btns[17].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[18]) { // 如果点击的是第18个按钮（*，乘法）
//            math();
//            str = textResult.getText();
//            String s = textReview.getText();
//            textReview.setText(s + str + btns[18].getText());
//            textResult.setText("0");
//        } else if (e.getSource() == btns[19]) { // 如果点击的是第19个按钮（1/x，倒数）
//            math(); // 执行数学运算，确保状态更新
//            str = textResult.getText(); // 获取结果文本框的内容
//            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                double s = 0; // 初始化一个double变量用于存储结果
//                try {
//                    s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                    s = 1.0 / s; // 计算倒数
//                } catch (NumberFormatException e1) { // 捕获数字格式异常
//                    try {
//                        s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                        s = 1.0 / s; // 计算倒数
//                    } catch (NumberFormatException e2) { // 捕获数字格式异常
//                        // 此处可以添加错误处理逻辑
//                    }
//                }
//                textResult.setText("" + s); // 将结果显示在结果文本框
//            } else { // 如果结果文本框为空
//                str = textReview.getText(); // 获取审查文本框的内容
//                double s = 0; // 初始化一个double变量用于存储结果
//                try {
//                    s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                    s = 1.0 / s; // 计算倒数
//                } catch (NumberFormatException e1) { // 捕获数字格式异常
//                    try {
//                        s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                        s = 1.0 / s; // 计算倒数
//                    } catch (NumberFormatException e2) { // 捕获数字格式异常
//                        // 此处可以添加错误处理逻辑
//                    }
//                }
//                textReview.setText("" + s); // 将结果显示在审查文本框
//            }
//        } else if (e.getSource() == btns[20]) { // 如果点击的是第20个按钮（数字1）
//            number(btns[20].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[21]) { // 如果点击的是第21个按钮（数字2）
//            number(btns[21].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[22]) { // 如果点击的是第22个按钮（数字3）
//            number(btns[22].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[23]) { // 如果点击的是第23个按钮（-，减法）
//            math();
//            str = textResult.getText();
//            String s = textReview.getText();
//            textReview.setText(s + str + btns[23].getText());
//            textResult.setText("0");
//        } else if (e.getSource() == btns[24]) { // 如果点击的是第24个按钮（x^2，平方）
//            math(); // 执行数学运算，确保状态更新
//            str = textResult.getText(); // 获取结果文本框的内容
//            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                try {
//                    long s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                    s = s * s; // 计算平方
//                    textResult.setText("" + s); // 将结果显示在结果文本框
//                } catch (NumberFormatException e1) { // 捕获数字格式异常
//                    try {
//                        double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                        s = s * s; // 计算平方
//                        textResult.setText("" + s); // 将结果显示在结果文本框
//                    } catch (NumberFormatException e2) { // 捕获数字格式异常
//                        // 此处可以添加错误处理逻辑
//                    }
//                }
//            } else { // 如果结果文本框为空
//                str = textReview.getText(); // 获取审查文本框的内容
//                try {
//                    long s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                    s = s * s; // 计算平方
//                    textReview.setText("" + s); // 将结果显示在审查文本框
//                } catch (NumberFormatException e1) { // 捕获数字格式异常
//                    try {
//                        double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                        s = s * s; // 计算平方
//                        textReview.setText("" + s); // 将结果显示在审查文本框
//                    } catch (NumberFormatException e2) { // 捕获数字格式异常
//                        // 此处可以添加错误处理逻辑
//                    }
//                }
//            }
//        } else if (e.getSource() == btns[25]) { // 如果点击的是第25个按钮（数字0）
//            number(btns[25].getText()); // 调用数字输入处理方法
//        } else if (e.getSource() == btns[26]) { // 如果点击的是第26个按钮（.，小数点）
//            str = textResult.getText(); // 获取结果文本框的内容
//            if (str.indexOf('.') == -1) // 如果结果文本框中没有小数点
//                textResult.setText(str + btns[26].getText()); // 在结果文本框中添加小数点
//        } else if (e.getSource() == btns[27]) { // 如果点击的是第27个按钮（=，等于）
//            // math(); // 执行数学运算，确保状态更新
//            // String finalResult = textReview.getText(); // 获取计算后的结果
//
//            // // 保存历史记录
//            // String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new
//            // Date());
//            // saveHistory(timestamp, calculationProcess, finalResult); //
//            // 确保在每次计算结果后都调用saveHistory方法
//
//            // // 更新文本框显示
//            // textResult.setText(finalResult); // 将最终结果显示在结果文本框
//            // calculationProcess = ""; // 清空计算过程
//
//            // 保存历史记录
//	         String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
//	         String calculationProcess = textReview.getText() + textResult.getText() + "=";
//
//            math(); // 执行数学运算，确保状态更新
//
//            saveHistory(timestamp, calculationProcess, textReview.getText()); // 确保在每次计算结果后都调用saveHistory方法
//        } else if (e.getSource() == btns[28]) { // 如果点击的是第28个按钮（+，加法）
//            math();
//            str = textResult.getText();
//            String s = textReview.getText();
//            textReview.setText(s + str + btns[28].getText());
//            textResult.setText("0");
//        } else if (e.getSource() == btns[29]) { // 如果点击的是第29个按钮（OFF，关闭）
//            showHistoryDialog(); // 显示历史记录对话框
//        }
//    }
//
//    /**
//     * 执行数学运算
//     */
//    private void math() { // 定义一个方法，用于执行数学运算
//
////        // 保存历史记录
////        String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
////        String calculationProcess = textReview.getText() + textResult.getText() + "=";
//        boolean isNewRecord = false;
//
//        String currentText = textReview.getText() + textResult.getText(); // 获取文本框内容并合并
//        System.out.println(textReview.getText()); // 打印审查文本框的内容（用于调试）
//        for (int i = 1; i < currentText.length(); i++) { // 从第二个字符开始遍历
//            if (("" + currentText.charAt(i)).equals("+")) { // 如果当前字符是加号
//                isNewRecord = true; // 标记为新记录
//
//                String[] s = currentText.split("\\+"); // 根据加号分割字符串
//                System.out.println(s[0] + " " + s[1]); // 打印两个操作数（用于调试）
//
//                try {
//                    int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
//                    textResult.setText(""); // 清空结果文本框
//                    textReview.setText("" + sum); // 将结果显示在审查文本框
//
//                } catch (NumberFormatException e1) { // 捕获整数解析异常
//                    try {
//                        double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
//                        textResult.setText(""); // 清空结果文本框
//                        textReview.setText("" + sum); // 将结果显示在审查文本框
//                    } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                        e2.printStackTrace(); // 打印异常堆栈
//                    }
//                }
//            }
//            if (("" + currentText.charAt(i)).equals("-")) { // 如果当前字符是减号
//                String[] s = currentText.split("\\-"); // 根据减号分割字符串
//                if (currentText.charAt(0) == '-') { // 如果第一个字符是负号
//                    s[s.length - 2] = "-" + s[s.length - 2]; // 将被减数转换为负数
//                } else
//                    isNewRecord = true; // 标记为新记录
//                try {
//                    int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试执行减法
//                    textResult.setText(""); // 清空结果文本框
//                    textReview.setText("" + sum); // 将结果显示在审查文本框
//                } catch (NumberFormatException e1) { // 捕获整数解析异常
//                    try {
//                        double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试执行减法（浮点数）
//                        textResult.setText(""); // 清空结果文本框
//                        textReview.setText("" + sum); // 将结果显示在审查文本框
//                    } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                        // 在此处理异常
//                    }
//                }
//            }
//            if (("" + currentText.charAt(i)).equals("*")) { // 如果当前字符是乘号
//                isNewRecord = true; // 标记为新记录
//
//                String[] s = currentText.split("\\*"); // 根据乘号分割字符串
//                try {
//                    int sum = Integer.parseInt(s[0]) * Integer.parseInt(s[1]); // 尝试执行乘法
//                    textResult.setText(""); // 清空结果文本框
//                    textReview.setText("" + sum); // 将结果显示在审查文本框
//                } catch (NumberFormatException e1) { // 捕获整数解析异常
//                    try {
//                        double sum = Double.parseDouble(s[0]) * Double.parseDouble(s[1]); // 尝试执行乘法（浮点数）
//                        textResult.setText(""); // 清空结果文本框
//                        textReview.setText("" + sum); // 将结果显示在审查文本框
//                    } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                        e2.printStackTrace(); // 打印异常堆栈
//                    }
//                }
//            }
//            if (("" + currentText.charAt(i)).equals("/")) { // 如果当前字符是除号
//                isNewRecord = true; // 标记为新记录
//
//                String[] s = currentText.split("\\/"); // 根据除号分割字符串
//                try {
//                    if (Integer.parseInt(s[0]) % Integer.parseInt(s[1]) == 0) { // 检查是否整除
//                        int sum = Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行整数除法
//                        textResult.setText(""); // 清空结果文本框
//                        textReview.setText("" + sum); // 将结果显示在审查文本框
//                    } else { // 如果不能整除
//                        double sum = 1.0 * Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行浮点数除法
//                        textResult.setText(""); // 清空结果文本框
//                        textReview.setText("" + sum); // 将结果显示在审查文本框
//                    }
//
//                } catch (NumberFormatException e1) { // 捕获整数解析异常
//                    try {
//                        double sum = Double.parseDouble(s[0]) / Double.parseDouble(s[1]); // 尝试执行浮点数除法
//                        textResult.setText(""); // 清空结果文本框
//                        textReview.setText("" + sum); // 将结果显示在审查文本框
//                    } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                        e2.printStackTrace(); // 打印异常堆栈
//                    }
//                }
//            }
//        }
//
////        saveHistory(timestamp, calculationProcess, textReview.getText()); // 确保在每次计算结果后都调用saveHistory方法
//    }
//
//    /**
//     * 处理数字按钮的输入
//     * 
//     * @param text 输入的数字文本
//     */
//    private void number(String text) { // 定义一个方法，用于处理数字输入
//        str = textResult.getText(); // 获取结果文本框的内容
//        try {
//            int s = Integer.parseInt(str); // 尝试将内容解析为整数
//            if (s == 0) { // 如果当前值为0
//                textResult.setText(text); // 将当前输入的数字设置为结果文本框的内容
//            } else { // 如果当前值不为0
//                textResult.setText(str + text); // 将当前输入的数字追加到结果文本框中
//            }
//        } catch (NumberFormatException e1) { // 捕获整数解析异常
//            try {
//                double s = Double.parseDouble(str); // 尝试将内容解析为浮点数
//                textResult.setText(str + text); // 将当前输入的数字追加到结果文本框中
//            } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                e2.printStackTrace(); // 打印异常堆栈
//            }
//        }
//    }
//
//    /**
//     * 主程序入口
//     * 
//     * @param args 命令行参数
//     */
//    public static void main(String[] args) { // 定义主程序入口
//        try {
//            Class.forName("com.hxtt.sql.access.AccessDriver"); // 加载Access数据库驱动
//        } catch (ClassNotFoundException e) { // 捕获类未找到异常
//            // 处理异常，比如记录日志或显示错误消息
//            e.printStackTrace(); // 打印异常堆栈
//        }
//        new Testyyl("计算器"); // 创建计算器实例并显示窗口
//    }
//
//    @Override
//    public void caretUpdate(CaretEvent e) { // 实现CaretListener接口中的方法，处理光标更新事件
//        // TODO Auto-generated method stub
//    }
//}

package xixi;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;
import java.util.ArrayList;
import java.awt.FlowLayout;
import java.sql.*;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.*;
import java.text.ParseException;

/**
 * 计算器类，继承自JFrame，实现了ActionListener和CaretListener接口
 * 
 * JFrame：
 * JFrame 是 Swing 包中的一个类，用于创建一个窗口界面。它是所有顶层窗口的基本类型，提供了图形用户界面的框架。
 * JFrame 可以包含各种图形组件，如按钮、标签、文本框等，通过设置布局管理器，用户可以控制这些组件的显示方式。
 * 主要的功能包括设置窗口标题、设置窗口大小、设置关闭操作、添加组件和显示窗口等。
 * 
 * ActionListener：
 * ActionListener 是一个接口，用于处理按钮点击等动作事件。当用户在 GUI 中执行某个动作（如点击按钮）时，将触发相应的事件。
 * 开发者需要实现 actionPerformed(ActionEvent e) 方法，以定义在事件发生时应该执行的操作。
 * 通过为组件（如按钮）添加这个监听器，可以响应用户的交互。
 * 
 * CaretListener：
 * CaretListener 也是一个接口，用于监听文本组件（如 JTextField 或 JTextArea）中光标的移动事件。
 * 当文本框中的光标位置变化时，将触发 caretUpdate(CaretEvent e)
 * 方法，开发者可以在这个方法中处理光标移动后的逻辑，例如更新某些组件的状态或者显示相关信息。
 * 这个监听器通常用来监控用户在文本框中进行输入或删除操作后的光标位置变化
 */
public class Testyyl extends JFrame implements ActionListener, CaretListener { // 定义Test类，继承自JFrame并实现ActionListener和CaretListener接口
    private JTextField textResult, textReview; // 定义两个文本框，一个用于显示结果，另一个用于显示输入的数学表达式
    private JButton btns[] = new JButton[30]; // 定义一个按钮数组，预留30个按钮
    // private String str1, str2; // str1用于存储历史输入的数学表达式，str2用于存储当前输入的数学表达式
    private String str; // 用于存储当前输入的值
    private String memory; // 用于存储数值的内存
    private JPanel menuPanel; // 自定义的菜单栏面板
    private JButton menuButton; // “≡”按钮，用于显示或隐藏菜单
    private boolean isMenuVisible = false; // 标记菜单栏是否可见
    // 声明一个用于显示历史记录的窗口
    private JDialog historyDialog; // 历史记录对话框

    /**
     * 构造方法，初始化计算器界面和组件
     * 
     * @param str 窗口标题
     */
    public Testyyl(String str) { // 构造方法接收窗口标题参数
        super(str); // 调用父类构造方法设置窗口标题
        this.setBounds(600, 150, 420, 520); // 设置窗口的大小和位置
        this.setDefaultCloseOperation(EXIT_ON_CLOSE); // 设置关闭窗口时退出程序
        // this.setResizable(false); // 不允许调整窗口大小
        this.getContentPane().setBackground(Color.lightGray); // 设置内容面板的背景颜色为浅灰色
        this.getContentPane().setLayout(new BorderLayout()); // 设置内容面板的布局为边界布局

        JPanel p1 = new JPanel(); // 创建一个新的JPanel
        p1.setLayout(new BorderLayout(0, 0)); // 设置面板的布局为边界布局

        // 初始化文本框
        textResult = createTextField("0", 20); // 创建一个用于显示结果的文本框
        textReview = createTextField(textResult.getText(), 12); // 创建一个用于显示输入的文本框
        textReview.setEditable(false); // 设置审查文本框为只读

        // 初始化菜单按钮
        menuButton = new JButton("≡"); // 创建菜单按钮
        menuButton.addActionListener(new ActionListener() { // 为菜单按钮添加动作监听器
            @Override
            public void actionPerformed(ActionEvent e) { // 点击事件处理
                toggleMenuVisibility(); // 切换菜单的可见性
            }
        });

        JPanel northPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); // 创建一个新的面板，布局为左对齐的流布局
        northPanel.add(createPanel(textReview, textResult)); // 添加文本框面板到北部区域
        northPanel.add(menuButton); // 添加菜单按钮到北部区域
        p1.add(northPanel, BorderLayout.NORTH); // 将新面板添加到p1的北部区域

        // 设置面板及文本框布局
        setupPanels(p1); // 自定义设置面板布局

        this.getContentPane().add(p1, BorderLayout.NORTH); // 将主面板添加到内容面板的北部

        JPanel p2 = new JPanel(); // 创建一个面板用于放置按钮
        p2.setLayout(new GridLayout(6, 5, 10, 10)); // 设置为6行5列的网格布局
        btns = get(btns); // 初始化按钮数组
        setupButtons(p2); // 设置按钮
        this.getContentPane().add(p2, BorderLayout.CENTER); // 将按钮面板添加到内容面板的中心

        // 添加文本监听器
        textResult.addCaretListener(this); // 为结果文本框添加光标监听器
        textReview.addCaretListener(this); // 为审查文本框添加光标监听器

        // 创建自定义的垂直菜单栏
        menuPanel = new JPanel(); // 创建菜单面板
        menuPanel.setLayout(new BoxLayout(menuPanel, BoxLayout.Y_AXIS)); // 设置菜单面板的布局为垂直方向的BoxLayout
        menuPanel.setBackground(Color.LIGHT_GRAY); // 设置菜单面板的背景颜色为浅灰色
        menuPanel.setVisible(false); // 初始时菜单面板不可见

        // 添加菜单项
        String[] menuItems = { "日期计算", "进制转换" };
        for (String item : menuItems) { // 遍历所有菜单项
            JButton menuItemButton = new JButton(item); // 创建一个新的按钮，按钮文本为当前菜单项
            menuItemButton.addActionListener(new ActionListener() { // 为按钮添加动作监听器
                @Override
                public void actionPerformed(ActionEvent e) { // 正确处理按钮点击事件
                    switch (item) {
                        case "日期计算":
                            performDateCalculation(); // 调用日期计算逻辑
                            break;
                        case "进制转换":
                            performBaseConversion(); // 调用进制转换逻辑
                            break;
                    }
                }
            });

            menuPanel.add(menuItemButton); // 将菜单按钮添加到菜单面板中
        }

        // 将菜单栏添加到窗口中，但初始时不可见
        this.add(menuPanel, BorderLayout.WEST); // 将菜单面板添加到窗口的西部（左侧）

        this.setVisible(true); // 设置窗口可见
    }

    /**
     * 切换菜单可见性的方法
     */
    private void toggleMenuVisibility() { // 定义一个方法，用于切换菜单的可见性
        isMenuVisible = !isMenuVisible; // 反转菜单的可见状态
        menuPanel.setVisible(isMenuVisible); // 根据当前状态设置菜单面板的可见性

        // 调整窗口大小以适应菜单栏（可选）
        if (isMenuVisible) { // 如果菜单当前是可见的
            this.setSize(this.getWidth(), this.getHeight() + menuPanel.getPreferredSize().height); // 增加窗口高度，以适应菜单的高度
        } else { // 如果菜单当前是不可见的
            this.setSize(this.getWidth(), this.getHeight() - menuPanel.getPreferredSize().height); // 减少窗口高度，以适应菜单的高度
        }
    }

    private void performDateCalculation() {
        // 输入第一个日期
        String startDateString = JOptionPane.showInputDialog(this, "请输入起始日期（格式：yyyy-MM-dd）：");
        if (startDateString == null) {
            return; // 如果取消输入，直接返回
        }

        // 输入第二个日期
        String endDateString = JOptionPane.showInputDialog(this, "请输入结束日期（格式：yyyy-MM-dd）：");
        if (endDateString == null) {
            return; // 如果取消输入，直接返回
        }

        // 解析日期
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date startDate = dateFormat.parse(startDateString); // 解析起始日期
            Date endDate = dateFormat.parse(endDateString); // 解析结束日期

            // 计算两个日期之间的相差天数
            long differenceInMillis = endDate.getTime() - startDate.getTime(); // 毫秒差
            long daysDifference = differenceInMillis / (1000 * 60 * 60 * 24); // 计算天数

            // 显示结果
            JOptionPane.showMessageDialog(this, "两个日期之间相差 " + daysDifference + " 天");
        } catch (ParseException e) {
            JOptionPane.showMessageDialog(this, "日期格式不正确，请使用 `yyyy-MM-dd` 格式。", "错误", JOptionPane.ERROR_MESSAGE);
        }
    }

    private void performBaseConversion() {
        String input = JOptionPane.showInputDialog(this, "请输入一个十进制数：");
        if (input != null) {
            try {
                int decimal = Integer.parseInt(input);
                String binary = Integer.toBinaryString(decimal); // 转换为二进制
                String octal = Integer.toOctalString(decimal); // 转换为八进制
                String hexadecimal = Integer.toHexString(decimal).toUpperCase(); // 转换为十六进制

                // 显示转换结果
                JOptionPane.showMessageDialog(this,
                        "二进制: " + binary + "\n" +
                                "八进制: " + octal + "\n" +
                                "十六进制: " + hexadecimal);
            } catch (NumberFormatException e) {
                JOptionPane.showMessageDialog(this, "无效输入，请输入一个有效的十进制数。", "错误", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

    /**
     * 显示历史记录对话框的方法
     */
    private void showHistoryDialog() { // 定义一个方法，用于显示历史记录对话框
        if (historyDialog == null) { // 检查历史记录对话框是否已经创建
            // 如果历史记录对话框尚未创建，则创建它
            historyDialog = new JDialog(this, "历史记录", true); // 创建一个模态对话框，标题为“历史记录”
            historyDialog.setSize(400, 300); // 设置对话框的大小为400x300像素
            historyDialog.setLayout(new BorderLayout()); // 设置对话框的布局为边界布局

            // 创建历史记录文本区域和滚动面板
            JTextArea historyTextArea = createHistoryTextArea(); // 调用方法创建历史记录文本区域
            JScrollPane scrollPane = new JScrollPane(historyTextArea); // 创建一个滚动面板，将文本区域放入其中
            historyDialog.add(scrollPane, BorderLayout.CENTER); // 将滚动面板添加到对话框的中心区域

            // 创建关闭按钮面板
            JPanel buttonPanel = new JPanel(); // 创建一个新的面板用于放置按钮
            JButton closeButton = new JButton("关闭"); // 创建一个关闭按钮，文本为“关闭”
            closeButton.addActionListener(new ActionListener() { // 为关闭按钮添加动作监听器
                @Override
                public void actionPerformed(ActionEvent e) { // 当按钮被点击时
                    historyDialog.dispose(); // 关闭对话框
                }
            });
            buttonPanel.add(closeButton); // 将关闭按钮添加到按钮面板中
            historyDialog.add(buttonPanel, BorderLayout.SOUTH); // 将按钮面板添加到对话框的南部区域

            // 填充历史记录数据（这里简化处理，你可以从数据库读取）
            ArrayList<String> historyList = readHistoryFromDatabase(); // 从数据库读取历史记录
            for (String history : historyList) { // 遍历历史记录列表
                historyTextArea.append(history + "\n"); // 将每条历史记录添加到文本区域中，并换行
            }
        }
        historyDialog.setVisible(true); // 显示对话框
    }

    /**
     * 创建历史记录文本区域的方法
     */
    private JTextArea createHistoryTextArea() { // 定义一个方法以创建历史记录文本区域
        JTextArea textArea = new JTextArea(); // 创建一个新的文本区域
        textArea.setEditable(false); // 设置文本区域为只读
        textArea.setLineWrap(true); // 启用自动换行
        textArea.setWrapStyleWord(true); // 设置在单词边界换行
        return textArea; // 返回创建的文本区域
    }

    /**
     * 保存历史记录到数据库的方法
     */
    private void saveHistory(String timestamp, String calculationProcess, String finalResult) { // 定义一个方法，用于保存历史记录到数据库
        String query = "INSERT INTO History (时间, 计算过程, 计算结果) VALUES (?, ?, ?)"; // 构建插入数据库的SQL语句
        try (Connection conn = DriverManager.getConnection("jdbc:Access:///D:/Access-files/Calculator-history.accdb"); // 连接到Access数据库
                PreparedStatement stmt = conn.prepareStatement(query)) { // 准备SQL语句
            stmt.setString(1, timestamp); // 设置第一个参数为时间戳
            stmt.setString(2, calculationProcess); // 设置第二个参数为计算过程
            stmt.setString(3, finalResult); // 设置第三个参数为计算结果
            stmt.executeUpdate(); // 执行插入操作
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈跟踪
        }
    }

    /**
     * 从数据库读取历史记录的方法
     */
    private ArrayList<String> readHistoryFromDatabase() { // 定义一个方法，用于从数据库读取历史记录
        ArrayList<String> historyList = new ArrayList<>(); // 创建一个ArrayList用于存储历史记录

        // 使用正确的列名，并且不要将列名放在引号中（除非它们是保留字或包含特殊字符）
        String query = "SELECT * FROM History"; // 构建查询数据库的SQL语句

        try (Connection conn = DriverManager.getConnection("jdbc:Access:///D:/Access-files/Calculator-history.accdb"); // 连接到Access数据库
                Statement stmt = conn.createStatement(); // 创建Statement对象用于执行查询
                ResultSet rs = stmt.executeQuery(query)) { // 执行查询并获取结果集

            while (rs.next()) { // 遍历结果集中的每一行
                String timestamp = rs.getString("时间"); // 读取时间戳
                String calculationProcess = rs.getString("计算过程"); // 读取计算过程
                String historyResult = rs.getString("计算结果"); // 读取计算结果
                // 根据需要格式化显示内容
                historyList.add(timestamp + "计算结果: " + calculationProcess + historyResult); // 将 formatted history
                // record 添加到历史记录列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈跟踪
        }
        return historyList; // 返回读取到的历史记录列表
    }

    /**
     * 创建文本框的方法
     */
    private JTextField createTextField(String text, int fontSize) {
        JTextField textField = new JTextField(text, 5);
        textField.setHorizontalAlignment(JTextField.RIGHT); // 设置文本框内容右对齐
        textField.setFont(new Font("Arial", Font.BOLD, fontSize)); // 设置文本框字体
        return textField;
    }

    /**
     * 设置面板及文本框布局
     */
    private void setupPanels(JPanel p1) {
        p1.add(createPanel(textReview, textResult), BorderLayout.CENTER);
        p1.add(new JPanel(), BorderLayout.WEST); // 西部面板
        p1.add(new JPanel(), BorderLayout.EAST); // 东部面板
        p1.add(new JPanel(), BorderLayout.SOUTH); // 南部面板
    }

    /**
     * 创建包含两个文本框的显示面板
     */
    private JPanel createPanel(JTextField topField, JTextField bottomField) {
        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(2, 1, 0, -2)); // 设置为2行1列的网格布局
        panel.add(topField); // 添加审查文本框
        panel.add(bottomField); // 添加结果文本框
        return panel;
    }

    /**
     * 设置按钮的方法
     */
    private void setupButtons(JPanel p2) {
        for (JButton btn : btns) { // 遍历按钮数组
            p2.add(btn); // 将每个按钮添加到面板中
            btn.setMargin(new Insets(0, 0, 0, 0)); // 设置按钮的边缘空余部分为0
            btn.setFont(new Font("Arial", Font.ROMAN_BASELINE, btn == btns[btns.length - 1] ? 12 : 15)); // 设置字体
            btn.addActionListener(this); // 为每个按钮添加事件监听器
        }
    }

    /**
     * 获取按钮数组并初始化按钮
     * 
     * @param btns2 按钮数组
     * @return 初始化后的按钮数组
     */
    private JButton[] get(JButton[] btns2) { // 定义一个方法，用于初始化按钮数组并返回它
        String[] buttonLabels = {
                "MC", "MR", "MS", "M+", "M-",
                "←", "CE", "C", "±", "√",
                "7", "8", "9", "/", "%",
                "4", "5", "6", "*", "1/x",
                "1", "2", "3", "-", "x^2",
                "0", ".", "=", "+", "OpenHistory"
        };

        for (int i = 0; i < btns.length; i++) {
            try {
                btns[i] = new JButton(buttonLabels[i]); // 初始化按钮
            } catch (ArrayIndexOutOfBoundsException e) {
                System.err.println("按钮初始化异常：" + e.getMessage()); // 错误处理
            }
        }

        return btns; // 返回初始化后的按钮数组
    }

    /**
     * 处理按钮的点击事件
     */
    public void actionPerformed(ActionEvent e) { // 实现ActionListener接口中的方法，处理按钮点击事件
        /*
         * MC（Memory Clear）：清除存储器中的数值。
         * MR（Memory Recall）：读取存储器中存储的数值。
         * MS（Memory Save）：将当前显示的数值存入存储器中。
         * M+（Memory Add）：将当前显示的数值与存储器中的数值相加，并将结果存入存储器。
         * M-（Memory Minus，部分计算器无此功能）：用存储器中的数值减去当前显示的数值，并将结果存入存储器（此功能并非所有计算器都具备）。
         */

        if (e.getSource() == btns[0]) { // 如果点击的是第0个按钮（MC）
            memory = "0"; // 将存储器中的数值清零
        } else if (e.getSource() == btns[1]) { // 如果点击的是第1个按钮（MR）
            str = memory; // 将结果文本框的内容设置为存储器中的数值
            textResult.setText(str);
        } else if (e.getSource() == btns[2]) { // 如果点击的是第2个按钮（MS）
            memory = textResult.getText(); // 将存储器中的数值设置为结果文本框的内容
        } else if (e.getSource() == btns[3]) { // 如果点击的是第3个按钮（M+）
            str = memory + "+" + textResult.getText();
            String[] s = str.split("\\+"); // 按加号分割字符串成数组
            System.out.println(s[0] + "   " + s[1]); // 打印两个操作数（用于调试）
            try {
                int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
                memory = String.valueOf(sum); // 更新存储器中的数值
            } catch (NumberFormatException e1) { // 捕获整数解析异常
                try {
                    double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
                    memory = String.valueOf(sum); // 更新存储器中的数值
                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                    e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
                }
            }
        } else if (e.getSource() == btns[4]) { // 如果点击的是第4个按钮（M-）
            str = memory + "-" + textResult.getText();
            String[] s = str.split("\\-"); // 按减号分割字符串成数组
            if (str.charAt(0) == '-') { // 如果字符串以负号开头
                s[s.length - 2] = "-" + s[s.length - 2]; // 将减去的数的符号变为负
                /*
                 * str.charAt(0) == '-'：检查字符串的第一个字符是否为负号。
                 * 如果是，则认为表达式是一个负数，接下来的操作数（即减去的数）也应为负数。
                 * 
                 * s[s.length - 2] = "-" + s[s.length - 2];：
                 * 找到数组 s 中倒数第二个元素（即被减数），将其前面加上一个负号，从而将它的符号变为负。
                 * 这是为了确保在后续的减法操作中，计算时能正确处理负数。
                 */
            }
            try {
                int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试将操作数解析为整数并相减
                memory = String.valueOf(sum); // 更新存储器中的数值
            } catch (NumberFormatException e1) { // 捕获整数解析异常
                try {
                    double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相减
                    memory = String.valueOf(sum); // 更新存储器中的数值
                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                    // 处理异常
                }
            }
        } else if (e.getSource() == btns[5]) { // 如果点击的是第5个按钮（←，退格）
            str = textResult.getText(); // 获取结果文本框的内容
            if (str.length() == 1) { // 如果字符串长度为1
                textResult.setText("0"); // 设置结果文本框为0
            } else { // 如果字符串长度大于1
                str = str.substring(0, str.length() - 1);
                textResult.setText(str); // 更新结果文本框为新字符串
            }
        } else if (e.getSource() == btns[6]) { // 如果点击的是第6个按钮（CE，清除当前输入）
            textResult.setText("0"); // 清空审查文本框
        } else if (e.getSource() == btns[7]) { // 如果点击的是第7个按钮（C，清除所有）
            textResult.setText("0"); // 将结果文本框清空并设置为0
            textReview.setText(""); // 清空审查文本框
        } else if (e.getSource() == btns[8]) { // 如果点击的是第8个按钮（±，正负号切换）
            math(); // 先执行数学运算（以确保状态更新）
            str = textReview.getText(); // 获取审查文本框的内容
            str = str.startsWith("-") ? str.substring(1, str.length()) : "-" + str; // 取反
            textReview.setText(str); // 更新审查文本框为新字符串
        } else if (e.getSource() == btns[9]) { // 如果点击的是第9个按钮（√，开方）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                    s = Math.sqrt(s); // 计算s的平方根
                } catch (NumberFormatException e2) { // 捕获数字格式异常
                    // 此处可以添加错误处理逻辑
                }
                textReview.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
                textResult.setText("0"); // 清空结果文本框并重置为0
            } else { // 如果结果文本框为空
                str = textReview.getText(); // 获取审查文本框的内容
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                    s = Math.sqrt(s); // 计算s的平方根
                } catch (NumberFormatException e2) { // 捕获数字格式异常
                    // 此处可以添加错误处理逻辑
                }
                textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
            }
        } else if (e.getSource() == btns[10]) { // 如果点击的是第10个按钮（数字7）
            number(btns[10].getText()); // 调用数字输入处理方法，传入按钮的文本
        } else if (e.getSource() == btns[11]) { // 如果点击的是第11个按钮（数字8）
            number(btns[11].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[12]) { // 如果点击的是第12个按钮（数字9）
            number(btns[12].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[13]) { // 如果点击的是第13个按钮（/，除法）
            math();
            str = textResult.getText();
            String s = textReview.getText();
            textReview.setText(s + str + btns[13].getText());
            textResult.setText("0");
        } else if (e.getSource() == btns[14]) { // 如果点击的是第14个按钮（%）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
                textResult.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
            } else { // 如果结果文本框为空
                str = textReview.getText(); // 获取审查文本框的内容
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
                textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
            }
        } else if (e.getSource() == btns[15]) { // 如果点击的是第15个按钮（数字4）
            number(btns[15].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[16]) { // 如果点击的是第16个按钮（数字5）
            number(btns[16].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[17]) { // 如果点击的是第17个按钮（数字6）
            number(btns[17].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[18]) { // 如果点击的是第18个按钮（*，乘法）
            math();
            str = textResult.getText();
            String s = textReview.getText();
            textReview.setText(s + str + btns[18].getText());
            textResult.setText("0");
        } else if (e.getSource() == btns[19]) { // 如果点击的是第19个按钮（1/x，倒数）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Integer.parseInt(str); // 尝试将字符串解析为整数
                    s = 1.0 / s; // 计算倒数
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                        s = 1.0 / s; // 计算倒数
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
                textResult.setText("" + s); // 将结果显示在结果文本框
            } else { // 如果结果文本框为空
                str = textReview.getText(); // 获取审查文本框的内容
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Integer.parseInt(str); // 尝试将字符串解析为整数
                    s = 1.0 / s; // 计算倒数
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                        s = 1.0 / s; // 计算倒数
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
                textReview.setText("" + s); // 将结果显示在审查文本框
            }
        } else if (e.getSource() == btns[20]) { // 如果点击的是第20个按钮（数字1）
            number(btns[20].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[21]) { // 如果点击的是第21个按钮（数字2）
            number(btns[21].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[22]) { // 如果点击的是第22个按钮（数字3）
            number(btns[22].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[23]) { // 如果点击的是第23个按钮（-，减法）
            math();
            str = textResult.getText();
            String s = textReview.getText();
            textReview.setText(s + str + btns[23].getText());
            textResult.setText("0");
        } else if (e.getSource() == btns[24]) { // 如果点击的是第24个按钮（x^2，平方）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
                try {
                    long s = Integer.parseInt(str); // 尝试将字符串解析为整数
                    s = s * s; // 计算平方
                    textResult.setText("" + s); // 将结果显示在结果文本框
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                        s = s * s; // 计算平方
                        textResult.setText("" + s); // 将结果显示在结果文本框
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
            } else { // 如果结果文本框为空
                str = textReview.getText(); // 获取审查文本框的内容
                try {
                    long s = Integer.parseInt(str); // 尝试将字符串解析为整数
                    s = s * s; // 计算平方
                    textReview.setText("" + s); // 将结果显示在审查文本框
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                        s = s * s; // 计算平方
                        textReview.setText("" + s); // 将结果显示在审查文本框
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
            }
        } else if (e.getSource() == btns[25]) { // 如果点击的是第25个按钮（数字0）
            number(btns[25].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[26]) { // 如果点击的是第26个按钮（.，小数点）
            str = textResult.getText(); // 获取结果文本框的内容
            if (str.indexOf('.') == -1) // 如果结果文本框中没有小数点
                textResult.setText(str + btns[26].getText()); // 在结果文本框中添加小数点
        } else if (e.getSource() == btns[27]) { // 如果点击的是第27个按钮（=，等于）
            // math(); // 执行数学运算，确保状态更新
            // String finalResult = textReview.getText(); // 获取计算后的结果

            // // 保存历史记录
            // String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new
            // Date());
            // saveHistory(timestamp, calculationProcess, finalResult); //
            // 确保在每次计算结果后都调用saveHistory方法

            // // 更新文本框显示
            // textResult.setText(finalResult); // 将最终结果显示在结果文本框
            // calculationProcess = ""; // 清空计算过程

            // 保存历史记录
            // String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new
            // Date());
            // String calculationProcess = textReview.getText() + textResult.getText() +
            // "=";

            math(); // 执行数学运算，确保状态更新

            // saveHistory(timestamp, calculationProcess, textReview.getText()); //
            // 确保在每次计算结果后都调用saveHistory方法
        } else if (e.getSource() == btns[28]) { // 如果点击的是第28个按钮（+，加法）
            math();
            str = textResult.getText();
            String s = textReview.getText();
            textReview.setText(s + str + btns[28].getText());
            textResult.setText("0");
        } else if (e.getSource() == btns[29]) { // 如果点击的是第29个按钮（OFF，关闭）
            showHistoryDialog(); // 显示历史记录对话框
        }
    }

    /**
     * 执行数学运算
     */
    private void math() { // 定义一个方法，用于执行数学运算

        // 保存历史记录
        String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        String calculationProcess = textReview.getText() + textResult.getText() + "=";
        boolean isNewRecord = false;

        String currentText = textReview.getText() + textResult.getText(); // 获取文本框内容并合并
        System.out.println(textReview.getText()); // 打印审查文本框的内容（用于调试）
        for (int i = 1; i < currentText.length(); i++) { // 从第二个字符开始遍历
            if (("" + currentText.charAt(i)).equals("+")) { // 如果当前字符是加号
                isNewRecord = true; // 标记为新记录

                String[] s = currentText.split("\\+"); // 根据加号分割字符串
                System.out.println(s[0] + " " + s[1]); // 打印两个操作数（用于调试）

                try {
                    int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将结果显示在审查文本框

                } catch (NumberFormatException e1) { // 捕获整数解析异常
                    try {
                        double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
                        textResult.setText(""); // 清空结果文本框
                        textReview.setText("" + sum); // 将结果显示在审查文本框
                    } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                        e2.printStackTrace(); // 打印异常堆栈
                    }
                }
            }
            if (("" + currentText.charAt(i)).equals("-")) { // 如果当前字符是减号
                String[] s = currentText.split("\\-"); // 根据减号分割字符串
                if (currentText.charAt(0) == '-') { // 如果第一个字符是负号
                    s[s.length - 2] = "-" + s[s.length - 2]; // 将被减数转换为负数
                } else
                    isNewRecord = true; // 标记为新记录
                try {
                    int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试执行减法
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将结果显示在审查文本框
                } catch (NumberFormatException e1) { // 捕获整数解析异常
                    try {
                        double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试执行减法（浮点数）
                        textResult.setText(""); // 清空结果文本框
                        textReview.setText("" + sum); // 将结果显示在审查文本框
                    } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                        // 在此处理异常
                    }
                }
            }
            if (("" + currentText.charAt(i)).equals("*")) { // 如果当前字符是乘号
                isNewRecord = true; // 标记为新记录

                String[] s = currentText.split("\\*"); // 根据乘号分割字符串
                try {
                    int sum = Integer.parseInt(s[0]) * Integer.parseInt(s[1]); // 尝试执行乘法
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将结果显示在审查文本框
                } catch (NumberFormatException e1) { // 捕获整数解析异常
                    try {
                        double sum = Double.parseDouble(s[0]) * Double.parseDouble(s[1]); // 尝试执行乘法（浮点数）
                        textResult.setText(""); // 清空结果文本框
                        textReview.setText("" + sum); // 将结果显示在审查文本框
                    } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                        e2.printStackTrace(); // 打印异常堆栈
                    }
                }
            }
            if (("" + currentText.charAt(i)).equals("/")) { // 如果当前字符是除号
                isNewRecord = true; // 标记为新记录

                String[] s = currentText.split("\\/"); // 根据除号分割字符串
                try {
                    if (Integer.parseInt(s[0]) % Integer.parseInt(s[1]) == 0) { // 检查是否整除
                        int sum = Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行整数除法
                        textResult.setText(""); // 清空结果文本框
                        textReview.setText("" + sum); // 将结果显示在审查文本框
                    } else { // 如果不能整除
                        double sum = 1.0 * Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行浮点数除法
                        textResult.setText(""); // 清空结果文本框
                        textReview.setText("" + sum); // 将结果显示在审查文本框
                    }

                } catch (NumberFormatException e1) { // 捕获整数解析异常
                    try {
                        double sum = Double.parseDouble(s[0]) / Double.parseDouble(s[1]); // 尝试执行浮点数除法
                        textResult.setText(""); // 清空结果文本框
                        textReview.setText("" + sum); // 将结果显示在审查文本框
                    } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                        e2.printStackTrace(); // 打印异常堆栈
                    }
                }
            }
        }

        if (isNewRecord)
            saveHistory(timestamp, calculationProcess, textReview.getText()); // 确保在每次计算结果后都调用saveHistory方法
    }

    /**
     * 处理数字按钮的输入
     * 
     * @param text 输入的数字文本
     */
    private void number(String text) { // 定义一个方法，用于处理数字输入
        str = textResult.getText(); // 获取结果文本框的内容
        try {
            int s = Integer.parseInt(str); // 尝试将内容解析为整数
            if (s == 0) { // 如果当前值为0
                textResult.setText(text); // 将当前输入的数字设置为结果文本框的内容
            } else { // 如果当前值不为0
                textResult.setText(str + text); // 将当前输入的数字追加到结果文本框中
            }
        } catch (NumberFormatException e1) { // 捕获整数解析异常
            try {
                double s = Double.parseDouble(str); // 尝试将内容解析为浮点数
                textResult.setText(str + text); // 将当前输入的数字追加到结果文本框中
            } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                e2.printStackTrace(); // 打印异常堆栈
            }
        }
    }

    /**
     * 主程序入口
     * 
     * @param args 命令行参数
     */
    public static void main(String[] args) { // 定义主程序入口
        try {
            Class.forName("com.hxtt.sql.access.AccessDriver"); // 加载Access数据库驱动
        } catch (ClassNotFoundException e) { // 捕获类未找到异常
            // 处理异常，比如记录日志或显示错误消息
            e.printStackTrace(); // 打印异常堆栈
        }
        new Testyyl("计算器"); // 创建计算器实例并显示窗口
    }

    @Override
    public void caretUpdate(CaretEvent e) { // 实现CaretListener接口中的方法，处理光标更新事件
        // TODO Auto-generated method stub
    }
}